…e-object-protocol-to-the-observable-macro

Migrating from the ObservableObject protocol to the @observable macro

Pulled in updated Willow and updated for Swift 6

#13)

Moves CBCentralManager, the discovered-peripherals list, and Combine
subjects into a new @globalActor BluetoothActor, with a
BluetoothDelegateShim bridging CBCentralManagerDelegate callbacks into
actor-isolated handlers. BluetoothManager and ReliaBLEManager become
thin async forwarders, PeripheralManager is folded into the actor, and
docs/demo call sites are updated for the new async API.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

- Restore stored peripheralIdentifier: seed in init, refresh in update,
  don't clear in invalidateCBPeripheral. Fixes refreshPeripherals after
  invalidation (Rec 1, Copilot comments #1/#2/#3).
- Restore dedicated serial DispatchQueue for CBCentralManager instead of
  queue: nil, keeping callbacks off the main thread (Rec 2, comment #9).
- Adopt plan-prescribed @BluetoothActor global-actor annotation in
  BluetoothDelegateShim Task hops (Rec 3, comment #6).
- Remove redundant nonisolated on hash(into:) and fix CBPeriphal typo
  in == doc comment (Rec 4, comments #4 partial / #5).

Co-Authored-By: Claude Opus 4.8 <[email protected]>

…6-safe

Introduce BluetoothActor to serialize CoreBluetooth state (Step 1 of 5)

Convert `Peripheral` from a reference-wrapping type into an immutable,
`Sendable` value snapshot that carries no `CBPeripheral` reference. The
live `CBPeripheral` is now owned exclusively by `BluetoothActor` in an
`id`-keyed registry that never escapes the actor; operations forward the
snapshot's `id` and the actor resolves the live reference, throwing
`PeripheralError.notFound` when a snapshot has gone stale.

- Add `AdvertisementData` to expose typed advertisement fields as values
- Add `PeripheralError` for stale/unresolvable snapshot lookups
- Add `CBUUID+Sendable` retroactive conformance
- Let apps pre-register a known peripheral via `Peripheral(id:)`
- Update `BluetoothActor` discovery to snapshot values and retain the
  non-`Sendable` CoreBluetooth payload only inside the actor
- Update DocC and tests for the new value-type API

I don't want this to be a tempting escape hatch later

I reviewed and all seem reasonable but will need validated with a build and test.

Co-authored-by: Copilot Autofix powered by AI <[email protected]>

Make Peripheral a Sendable value type (Step 2 of 5 for #10)

…f 5, #10)

Replace the three AnyPublisher surfaces on ReliaBLEManager (state,
peripheralDiscoveries, discoveredPeripherals) with per-subscription
AsyncStreams fed by an in-BluetoothActor broadcaster, and remove Combine
from Sources/ReliaBLE and the Demo.

- BluetoothActor: three [UUID: AsyncStream.Continuation] dictionaries replace
  the Combine subjects/publishers; nonisolated stream factories mint a fresh
  stream per call and register on an actor hop. state/discoveredPeripherals
  replay their latest value (.bufferingNewest(1)); peripheralDiscoveries does
  not replay (unbounded). currentBluetoothState retained as the sync
  currentState backing + state replay source.
- BluetoothManager/ReliaBLEManager: retype the three properties to AsyncStream.
- Demo: consume via .task { for await } loops feeding @mainactor handlers;
  drop cancellables/setupSubscriptions.
- Tests: add broadcaster coverage (multi-subscriber replay, fan-out, no-replay).
- DocC: replace .sink examples with for await; document streaming semantics.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

dropping the indirection layer now that the actor work is done directly.

Move BluetoothState/AuthorizationError types and the actor-isolated
state snapshot onto ReliaBLEManager, delete BluetoothManager.swift,
and update docs/tests to match the new public surface.

Replace Combine event surfaces with AsyncStream broadcaster (Step 3 of 5, #10)

Mark ReliaBLEConfig Sendable, and add DocC concurrency guide.

Make Swift 6 language mode and complete strict concurrency explicit in
Package.swift for the ReliaBLE and ReliaBLEMock targets rather than
relying on the swift-tools-version default, mark ReliaBLEConfig as
Sendable, and document the actor isolation contract in a new DocC
Concurrency article. Also record the planning and critique notes for
this step of the Swift 6 migration.

Move all SwiftData persistence in the Central tab off the main thread
by introducing `DeviceStoreActor`, a `ModelActor` created off-main via
`create(container:)`. `CentralView` now wires reliaBLE streams and the
store through a single `.task`/`withTaskGroup`, `CentralViewModel`
keeps only UI state and BLE actions, and `Demo/AGENTS.md` documents
the new pattern. Adds the accompanying planning doc.

Added Swift 6 strict concurrency checking (Step 5 of 5, #10)

Use Task.detached in create(container:) so ModelActor construction is
guaranteed off-main even when called from SwiftUI .task. Use
peripheral.lastSeen consistently on new Device inserts. Fix AGENTS.md
to describe manual ModelActor conformance, not the @Modelactor macro.

Demo: route SwiftData writes through background DeviceStoreActor (#20)

…elegate callbacks, suspend authorize

- peripheralDiscoveriesStream: bound buffer to .bufferingNewest(10_000) (~10MB cap)
  instead of unbounded, so a stalled subscriber drops oldest events rather than growing
  memory without limit.
- ensureInitialized(log:): idempotent actor setup that every public ReliaBLEManager entry
  point funnels through, closing the init-vs-immediate-call race. It also (re)creates the
  central manager on any entry when already .allowedAlways, so operations work after
  out-of-band authorization while preserving the lazy-permission contract.
- Ordered delegate handling: BluetoothDelegateShim yields each callback into a single
  AsyncStream<DelegateEvent> drained by one consumer task, preserving CoreBluetooth's
  serial callback order (replaces per-callback Tasks that could reorder).
- Suspending authorize: .notDetermined now suspends until centralManagerDidUpdateState
  resolves the decision; cancellation is wired via withTaskCancellationHandler in the
  nonisolated ReliaBLEManager facade, keeping the actor method clear of a construct the
  Swift 6.1 region-isolation checker cannot analyze.
- connect(to:) throws PeripheralError.bluetoothUnavailable (new case; enum now Equatable)
  when no central manager exists, instead of silently returning.
- Expanded the FR-8.5 TODO documenting the same-name peripheral identity collision.
- Tests updated for the new behaviors (cancellable authorize, broadened connect error).

Co-Authored-By: Claude Opus 4.8 <[email protected]>

…overies

- GettingStarted: authorizeBluetooth() now suspends until the user responds and
  returns only when authorized (and is cancellable) — document the new behavior in
  place of the old "no-op" note.
- GettingStarted: the connect(to:) example now also handles
  PeripheralError.bluetoothUnavailable.
- GettingStarted & Concurrency: note that the peripheralDiscoveries feed is bounded
  (drops the oldest pending advertisements under backpressure).

Co-Authored-By: Claude Opus 4.8 <[email protected]>

Previously, PeripheralManager unconditionally instantiated CBPeripheralManager
in init(), causing the system Bluetooth permission prompt on a fresh app launch.

Move creation into startAdvertising() so the prompt only appears when the
user explicitly chooses to use the peripheral advertising feature. This
prevents the demo from appearing to trigger authorization automatically
(via the library or otherwise).

Also update the Start button enable logic to allow activation while the
manager is still uninitialized.